package org.example.study11;

/**
 * 传统方式实现线程结果返回的示例
 * 创建线程计算 1+2+3+...+1000，不使用 Callable 版本
 */
public class TraditionalThreadResult {

    // 结果封装类，用于保存线程执行结果和同步控制
    static class Result {
        public int sum = 0;                    // 保存累加结果
        public Object lock = new Object();     // 用于同步的锁对象
    }

    public static void main(String[] args) throws InterruptedException {
        Result result = new Result();          // 创建共享结果对象

        // 创建计算线程
        Thread t = new Thread() {
            @Override
            public void run() {
                System.out.println("计算线程开始执行...");
                int sum = 0;
                // 执行累加计算：1+2+3+...+1000
                for (int i = 1; i <= 1000; i++) {
                    sum += i;
                }
                System.out.println("计算线程执行完成，结果: " + sum);

                // 同步块，确保结果的安全赋值和通知
                synchronized (result.lock) {
                    result.sum = sum;          // 将计算结果保存到共享对象
                    result.lock.notify();      // 通知等待的主线程
                    // notify()方法：唤醒在此对象监视器上等待的单个线程
                    // 如果有多个线程在等待，随机选择一个唤醒
                }// 同步块结束，自动释放锁
            }
        };
        t.start();  // 启动计算线程

        System.out.println("主线程开始等待计算结果...");

        // 主线程等待计算结果
        synchronized (result.lock) {
            // 检查结果是否已经计算完成（防止虚假唤醒）
            // 使用while而不是if，确保被唤醒后条件确实满足
            while (result.sum == 0) {
                result.lock.wait();  // 等待计算线程的通知
                // wait()方法：使当前线程等待，直到另一个线程调用该对象的notify()或notifyAll()
                // 调用wait()会释放对象锁，允许其他线程进入同步块
            }
            // 打印最终结果
            System.out.println("最终计算结果: " + result.sum);
        }
    }
}

/*输出：
主线程开始等待计算结果...
计算线程开始执行...
计算线程执行完成，结果: 500500
最终计算结果: 500500*/